/// <reference path="../../lib/excalibur.d.ts" />

(function () {
  var game = new ex.Engine({
    width: 600,
    height: 400,
    physics: {
      solver: ex.SolverStrategy.Realistic,
      gravity: ex.vec(0, 200)
    }
  });
  game.showDebug(true);

  var floor = new ex.Actor({
    pos: new ex.Vector(game.halfDrawWidth, game.drawHeight),
    anchor: new ex.Vector(0.5, 0.5),
    width: game.drawWidth,
    height: 40,
    color: ex.Color.Black,
    collisionType: ex.CollisionType.Fixed
  });

  var block = new ex.Actor({
    pos: new ex.Vector(game.halfDrawWidth + 200, game.drawHeight - 125),
    width: 50,
    height: 50,
    color: ex.Color.Green,
    collisionType: ex.CollisionType.Fixed
  });

  var block2 = new ex.Actor({
    pos: new ex.Vector(game.halfDrawWidth, game.drawHeight - 45),
    width: 50,
    height: 50,
    color: ex.Color.Green,
    collisionType: ex.CollisionType.Fixed
  });

  var block3 = new ex.Actor({
    pos: new ex.Vector(game.halfDrawWidth, game.drawHeight - 200),
    width: 50,
    height: 50,
    color: ex.Color.Green,
    collisionType: ex.CollisionType.Fixed
  });

  var block4 = new ex.Actor({
    pos: new ex.Vector(game.halfDrawWidth, game.drawHeight - 255),
    width: 50,
    height: 50,
    color: ex.Color.Green,
    collisionType: ex.CollisionType.Fixed
  });

  var otherCircle = new ex.Actor({
    pos: new ex.Vector(400, 100),
    color: ex.Color.Green
  });
  otherCircle.collider.useCircleCollider(30);

  var otherBlock = new ex.Actor({
    pos: new ex.Vector(400, 400),
    rotation: Math.PI / 4,
    color: ex.Color.Red
  });
  otherBlock.collider.useBoxCollider(50, 50);

  var circle = new ex.Actor({
    pos: new ex.Vector(300, 300),
    color: ex.Color.Green
  });
  circle.collider.useCircleCollider(40);

  // circle.onPostDraw = (ctx, delta) => {
  //   const closestEdge = circle.collider.get().getClosestLineBetween(edge.collider.get());
  //   const closestCircle = circle.collider.get().getClosestLineBetween(otherCircle.collider.get());
  //   const closestPolygon = circle.collider.get().getClosestLineBetween(otherBlock.collider.get());

  //   ctx.restore();
  //   ctx.save();

  //   ctx.fillStyle = ex.Color.Blue.toString();
  //   ctx.fillText('Closest edge line length:' + closestEdge.getLength(), circle.pos.x + 20, circle.pos.y + 30);
  //   ex.Util.DrawUtil.line(ctx, ex.Color.Blue, closestEdge.begin.x, closestEdge.begin.y, closestEdge.end.x, closestEdge.end.y, 3);

  //   ctx.fillStyle = ex.Color.Green.toString();
  //   ctx.fillText('Closest circle line length:' + closestCircle.getLength(), circle.pos.x + 20, circle.pos.y + 45);
  //   ex.Util.DrawUtil.line(ctx, ex.Color.Green, closestCircle.begin.x, closestCircle.begin.y, closestCircle.end.x, closestCircle.end.y, 3);

  //   ctx.fillStyle = ex.Color.Red.toString();
  //   ctx.fillText('Closest polygon line length:' + closestPolygon.getLength(), circle.pos.x + 20, circle.pos.y + 60);
  //   ex.Util.DrawUtil.line(ctx, ex.Color.Red, closestPolygon.begin.x, closestPolygon.begin.y, closestPolygon.end.x, closestPolygon.end.y, 3);
  // };

  var edge = new ex.Actor({
    pos: new ex.Vector(100, 300),
    color: ex.Color.Blue
  });
  edge.collider.useEdgeCollider(new ex.Vector(0, 0), new ex.Vector(30, 100));

  var blocks = [block, block2, block3, block4];

  blocks.forEach((b) => {
    b.onPostUpdate = (engine, delta) => {
      if (b.within(floor, 200)) {
        b.color = ex.Color.Red;
      } else {
        b.color = ex.Color.Green;
      }
    };
    b.graphics.onPostDraw = (ctx, delta) => {
      const closestPolygon = b.collider.get().getClosestLineBetween(floor.collider.get());
      const closestCircle = b.collider.get().getClosestLineBetween(circle.collider.get());
      const closestEdge = b.collider.get().getClosestLineBetween(edge.collider.get());
      ctx.restore();
      ctx.save();

      ctx.debug.drawText('Closest polygon line length:' + closestPolygon.getLength(), b.pos.add(ex.vec(20, 50)));
      ctx.drawLine(closestPolygon.begin, closestPolygon.end, ex.Color.Red, 3);

      ctx.debug.drawText('Closest circle line length:' + closestCircle.getLength(), b.pos.add(ex.vec(20, 65)));
      ctx.drawLine(closestCircle.begin, closestCircle.end, ex.Color.Green, 3);

      ctx.debug.drawText('Closest edge line length:' + closestEdge.getLength(), b.pos.add(ex.vec(20, 80)));
      ctx.drawLine(closestEdge.begin, closestEdge.end, ex.Color.Blue, 3);
    };
  });
  if (block.within(floor, 200)) {
    block.color = ex.Color.Red;
  }

  if (block2.within(floor, 200)) {
    block2.color = ex.Color.Red;
  }

  if (block3.within(floor, 200)) {
    block3.color = ex.Color.Red;
  }

  if (block4.within(floor, 200)) {
    block4.color = ex.Color.Red;
  }

  game.input.keyboard.on('press', (evt) => {
    if (evt.key === ex.Keys.R) {
      block4.rotation += 0.2;
    }
    if (evt.key === ex.Keys.E) {
      block4.rotation -= 0.2;
    }

    var keyDist = 5;
    if (evt.key === ex.Keys.Up) {
      block4.pos.addEqual(new ex.Vector(0, -keyDist));
    }

    if (evt.key === ex.Keys.Down) {
      block4.pos.addEqual(new ex.Vector(0, keyDist));
    }

    if (evt.key === ex.Keys.Right) {
      block4.pos.addEqual(new ex.Vector(keyDist, 0));
    }

    if (evt.key === ex.Keys.Left) {
      block4.pos.addEqual(new ex.Vector(-keyDist, 0));
    }
  });

  game.add(otherCircle);
  game.add(otherBlock);
  game.add(circle);
  game.add(edge);
  game.add(block4);
  game.add(floor);
  game.start();
})();
